//类与对象
 import static java.lang.Math.*;
//声明一个对象
class Dog {
    //成员属性
    public String name;
    public int age;
    public String color;

    //成员方法
    public void eat(){
        System.out.println(name + "吃骨头~~");
    }
    public void barks(){
        System.out.println(name + "汪汪汪~~");
    }

    public void wag(){
        System.out.println(name + "摇尾巴~~");
    }
}

//构造方法演示
class Student{
    private String name;
    private int age;
    private String sex;


    //静态成员变量
    public static String classRoom;  //所处班级

    //当成员变量被static修饰时，该成员变量就不存在于对象之中，存放于方法区，属于所有类对象共享

    //就地初始化
//    public String name = "siri";
//    public int age = 20;
//    public String sex = "男";

    //右边generate可以让编译器生成get和set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    //实例代码块
    {
        this.name = "xiaowang";
        this.age = 18;
        this.sex = "女";
        System.out.println("这是一个实例代码块！");
    }

    //静态代码块
    static {
        classRoom = "109";
        System.out.println("这是一个静态代码块！");
    }


    //构造方法(当程序员没有写构造方法时，编译器会默认创建一个构造方法！)
    //作用：对对象中的成员进行初始化
    //名字必须与类名相同
    public Student(){
        //this(); //表示调用类中的其他构造方法
        //只能在当前的构造方法内部来使用，并且只能出现在第一行！
        this("lisi",20, "女");
        System.out.println("不带任何参数的构造方法");

    }

    //当类中有写构造方法，编译器便不会再提供默认的构造方法
    public Student(String name, int age, String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("带三个参数的构造方法");
    }
    public void study(){
        System.out.println(this.name + "正在学习");
        this.printInfo();//调用当前对象的其他方法
    }
    //打印信息
    public void printInfo(){
        System.out.println("姓名：" + name + " " + "年龄" + age + "性别" + sex);
    }

    //静态成员方法
    public static void func(){
        System.out.println("func()");

        //静态方法里面不能直接调用非静态方法
        //study();//error

        //要想调用，必须先实例化一个对象，用对象去调用非静态方法
        Student s = new Student();
        s.study();
    }
}
public class Main {
    public static void main(String[] args){

        //只执行一次静态代码块
        //实例代码块在创建对象之后才会被执行
//        Student stu = new Student();
//        System.out.println("===============");
//        Student stu2 = new Student();

        //静态代码块是只要类被加载，就会被执行
        System.out.println(Student.classRoom);
    }
    public static void main2(String[] args){
        //实例化student对象
        //在创建对象时，编译器会自动调用，并且在整个对象的声明周期内调用一次
//        Student stu = new Student();
//        Student stu2 = new Student("zhangsan",18, "男");
        //stu.name = "nihao";

//        stu2.classRoom = "109";
//        Student stu3 = new Student("LaoLiu", 22, "男");
//        stu3.classRoom = "109";
//        Student stu4 = new Student("LaoHuang", 23, "男");
//        stu4.classRoom = "109";

       //当成员变量被static修饰后，用类名.静态成员变量名方式访问
        Student.classRoom = "109";

        //类中静态成员方法的调用
        //使用类名.静态成员方法
        Student.func();
    }
    public static void main1(String[] args) {
        //实例化一个对象
        Dog dog = new Dog();

        dog.name = "旺财";
        dog.age = 5;
        dog.color = "黑色";

        System.out.println(dog.name);
        System.out.println(dog.age);
        System.out.println(dog.color);
        dog.eat();

        System.out.println("======================");
        //实例化第二个对象
        Dog dog2 = new Dog();
        dog2.name = "小黄";
        dog2.age = 8;
        dog2.color = "黄色";
        System.out.println(dog2.name);
        System.out.println(dog2.age);
        System.out.println(dog2.color);
        dog2.eat();
        dog2.barks();
    }
}